https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;h=2a35e0ca14e8cd9b1bc5a79ee341d10720269103
commit 2a35e0ca14e8cd9b1bc5a79ee341d10720269103
Author: Jeremy Drake <cyg...@jdrake.com>
Date: Wed Mar 26 12:48:04 2025 -0700
Cygwin: vendor libudis86 1.7.2/libudis86
This does not include the source files responsible for generating AT&T-
or Intel-syntax assembly output, or upstream's Makefile.{am,in}.
Signed-off-by: Jeremy Drake <cyg...@jdrake.com>
Diff:
---
winsup/cygwin/udis86/decode.c | 1112 ++++++
winsup/cygwin/udis86/decode.h | 195 +
winsup/cygwin/udis86/extern.h | 105 +
winsup/cygwin/udis86/itab.c | 8401 +++++++++++++++++++++++++++++++++++++++++
winsup/cygwin/udis86/itab.h | 678 ++++
winsup/cygwin/udis86/types.h | 250 ++
winsup/cygwin/udis86/udint.h | 89 +
winsup/cygwin/udis86/udis86.c | 457 +++
8 files changed, 11287 insertions(+)
diff --git a/winsup/cygwin/udis86/decode.c b/winsup/cygwin/udis86/decode.c
new file mode 100644
index 000000000..b4efa778c
--- /dev/null
+++ b/winsup/cygwin/udis86/decode.c
@@ -0,0 +1,1112 @@
+/* udis86 - libudis86/decode.c
+ *
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
notice,
+ * this list of conditions and the following disclaimer in the
documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "udint.h"
+#include "types.h"
+#include "decode.h"
+
+#ifndef __UD_STANDALONE__
+# include <string.h>
+#endif /* __UD_STANDALONE__ */
+
+/* The max number of prefixes to an instruction */
+#define MAX_PREFIXES 15
+
+/* rex prefix bits */
+#define REX_W(r) ( ( 0xF & ( r ) ) >> 3 )
+#define REX_R(r) ( ( 0x7 & ( r ) ) >> 2 )
+#define REX_X(r) ( ( 0x3 & ( r ) ) >> 1 )
+#define REX_B(r) ( ( 0x1 & ( r ) ) >> 0 )
+#define REX_PFX_MASK(n) ( ( P_REXW(n) << 3 ) | \
+ ( P_REXR(n) << 2 ) | \
+ ( P_REXX(n) << 1 ) | \
+ ( P_REXB(n) << 0 ) )
+
+/* scable-index-base bits */
+#define SIB_S(b) ( ( b ) >> 6 )
+#define SIB_I(b) ( ( ( b ) >> 3 ) & 7 )
+#define SIB_B(b) ( ( b ) & 7 )
+
+/* modrm bits */
+#define MODRM_REG(b) ( ( ( b ) >> 3 ) & 7 )
+#define MODRM_NNN(b) ( ( ( b ) >> 3 ) & 7 )
+#define MODRM_MOD(b) ( ( ( b ) >> 6 ) & 3 )
+#define MODRM_RM(b) ( ( b ) & 7 )
+
+static int decode_ext(struct ud *u, uint16_t ptr);
+
+enum reg_class { /* register classes */
+ REGCLASS_GPR,
+ REGCLASS_MMX,
+ REGCLASS_CR,
+ REGCLASS_DB,
+ REGCLASS_SEG,
+ REGCLASS_XMM
+};
+
+ /*
+ * inp_start
+ * Should be called before each de-code operation.
+ */
+static void
+inp_start(struct ud *u)
+{
+ u->inp_ctr = 0;
+}
+
+
+static uint8_t
+inp_next(struct ud *u)
+{
+ if (u->inp_end == 0) {
+ if (u->inp_buf != NULL) {
+ if (u->inp_buf_index < u->inp_buf_size) {
+ u->inp_ctr++;
+ return (u->inp_curr = u->inp_buf[u->inp_buf_index++]);
+ }
+ } else {
+ int c;
+ if ((c = u->inp_hook(u)) != UD_EOI) {
+ u->inp_curr = c;
+ u->inp_sess[u->inp_ctr++] = u->inp_curr;
+ return u->inp_curr;
+ }
+ }
+ }
+ u->inp_end = 1;
+ UDERR(u, "byte expected, eoi received\n");
+ return 0;
+}
+
+static uint8_t
+inp_curr(struct ud *u)
+{
+ return u->inp_curr;
+}
+
+
+/*
+ * inp_uint8
+ * int_uint16
+ * int_uint32
+ * int_uint64
+ * Load little-endian values from input
+ */
+static uint8_t
+inp_uint8(struct ud* u)
+{
+ return inp_next(u);
+}
+
+static uint16_t
+inp_uint16(struct ud* u)
+{
+ uint16_t r, ret;
+
+ ret = inp_next(u);
+ r = inp_next(u);
+ return ret | (r << 8);
+}
+
+static uint32_t
+inp_uint32(struct ud* u)
+{
+ uint32_t r, ret;
+
+ ret = inp_next(u);
+ r = inp_next(u);
+ ret = ret | (r << 8);
+ r = inp_next(u);
+ ret = ret | (r << 16);
+ r = inp_next(u);
+ return ret | (r << 24);
+}
+
+static uint64_t
+inp_uint64(struct ud* u)
+{
+ uint64_t r, ret;
+
+ ret = inp_next(u);
+ r = inp_next(u);
+ ret = ret | (r << 8);
+ r = inp_next(u);
+ ret = ret | (r << 16);
+ r = inp_next(u);
+ ret = ret | (r << 24);
+ r = inp_next(u);
+ ret = ret | (r << 32);
+ r = inp_next(u);
+ ret = ret | (r << 40);
+ r = inp_next(u);
+ ret = ret | (r << 48);
+ r = inp_next(u);
+ return ret | (r << 56);
+}
+
+
+static inline int
+eff_opr_mode(int dis_mode, int rex_w, int pfx_opr)
+{
+ if (dis_mode == 64) {
+ return rex_w ? 64 : (pfx_opr ? 16 : 32);
+ } else if (dis_mode == 32) {
+ return pfx_opr ? 16 : 32;
+ } else {
+ UD_ASSERT(dis_mode == 16);
+ return pfx_opr ? 32 : 16;
+ }
+}
+
+
+static inline int
+eff_adr_mode(int dis_mode, int pfx_adr)
+{
+ if (dis_mode == 64) {
+ return pfx_adr ? 32 : 64;
+ } else if (dis_mode == 32) {
+ return pfx_adr ? 16 : 32;
+ } else {
+ UD_ASSERT(dis_mode == 16);
+ return pfx_adr ? 32 : 16;
+ }
+}
+
+
+/*
+ * decode_prefixes
+ *
+ * Extracts instruction prefixes.
+ */
+static int
+decode_prefixes(struct ud *u)
+{
+ int done = 0;
+ uint8_t curr, last = 0;
+ UD_RETURN_ON_ERROR(u);
+
+ do {
+ last = curr;
+ curr = inp_next(u);
+ UD_RETURN_ON_ERROR(u);
+ if (u->inp_ctr == MAX_INSN_LENGTH) {
+ UD_RETURN_WITH_ERROR(u, "max instruction length");
+ }
+
+ switch (curr)
+ {
+ case 0x2E:
+ u->pfx_seg = UD_R_CS;
+ break;
+ case 0x36:
+ u->pfx_seg = UD_R_SS;
+ break;
+ case 0x3E:
+ u->pfx_seg = UD_R_DS;
+ break;
+ case 0x26:
+ u->pfx_seg = UD_R_ES;
+ break;
+ case 0x64:
+ u->pfx_seg = UD_R_FS;
+ break;
+ case 0x65:
+ u->pfx_seg = UD_R_GS;
+ break;
+ case 0x67: /* adress-size override prefix */
+ u->pfx_adr = 0x67;
+ break;
+ case 0xF0:
+ u->pfx_lock = 0xF0;
+ break;
+ case 0x66:
+ u->pfx_opr = 0x66;
+ break;
+ case 0xF2:
+ u->pfx_str = 0xf2;
+ break;
+ case 0xF3:
+ u->pfx_str = 0xf3;
+ break;
+ default:
+ /* consume if rex */
+ done = (u->dis_mode == 64 && (curr & 0xF0) == 0x40) ? 0 : 1;
+ break;
+ }
+ } while (!done);
+ /* rex prefixes in 64bit mode, must be the last prefix */
+ if (u->dis_mode == 64 && (last & 0xF0) == 0x40) {
+ u->pfx_rex = last;
+ }
+ return 0;
+}
+
+
+static inline unsigned int modrm( struct ud * u )
+{
+ if ( !u->have_modrm ) {
+ u->modrm = inp_next( u );
+ u->have_modrm = 1;
+ }
+ return u->modrm;
+}
+
+
+static unsigned int
+resolve_operand_size( const struct ud * u, unsigned int s )
+{
+ switch ( s )
+ {
+ case SZ_V:
+ return ( u->opr_mode );
+ case SZ_Z:
+ return ( u->opr_mode == 16 ) ? 16 : 32;
+ case SZ_Y:
+ return ( u->opr_mode == 16 ) ? 32 : u->opr_mode;
+ case SZ_RDQ:
+ return ( u->dis_mode == 64 ) ? 64 : 32;
+ default:
+ return s;
+ }
+}
+
+
+static int resolve_mnemonic( struct ud* u )
+{
+ /* resolve 3dnow weirdness. */
+ if ( u->mnemonic == UD_I3dnow ) {
+ u->mnemonic = ud_itab[ u->le->table[ inp_curr( u ) ] ].mnemonic;
+ }
+ /* SWAPGS is only valid in 64bits mode */
+ if ( u->mnemonic == UD_Iswapgs && u->dis_mode != 64 ) {
+ UDERR(u, "swapgs invalid in 64bits mode\n");
+ return -1;
+ }
+
+ if (u->mnemonic == UD_Ixchg) {
+ if ((u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_AX &&
+ u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_AX) ||
+ (u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_EAX &&
+ u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_EAX)) {
+ u->operand[0].type = UD_NONE;
+ u->operand[1].type = UD_NONE;
+ u->mnemonic = UD_Inop;
+ }
+ }
+
+ if (u->mnemonic == UD_Inop && u->pfx_repe) {
+ u->pfx_repe = 0;
+ u->mnemonic = UD_Ipause;
+ }
+ return 0;
+}
+
+
+/*
-----------------------------------------------------------------------------
+ * decode_a()- Decodes operands of the type seg:offset
+ *
-----------------------------------------------------------------------------
+ */
+static void
+decode_a(struct ud* u, struct ud_operand *op)
+{
+ if (u->opr_mode == 16) {
+ /* seg16:off16 */
+ op->type = UD_OP_PTR;
+ op->size = 32;
+ op->lval.ptr.off = inp_uint16(u);
+ op->lval.ptr.seg = inp_uint16(u);
+ } else {
+ /* seg16:off32 */
+ op->type = UD_OP_PTR;
+ op->size = 48;
+ op->lval.ptr.off = inp_uint32(u);
+ op->lval.ptr.seg = inp_uint16(u);
+ }
+}
+
+/*
-----------------------------------------------------------------------------
+ * decode_gpr() - Returns decoded General Purpose Register
+ *
-----------------------------------------------------------------------------
+ */
+static enum ud_type
+decode_gpr(register struct ud* u, unsigned int s, unsigned char rm)
+{
+ switch (s) {
+ case 64:
+ return UD_R_RAX + rm;
+ case 32:
+ return UD_R_EAX + rm;
+ case 16:
+ return UD_R_AX + rm;
+ case 8:
+ if (u->dis_mode == 64 && u->pfx_rex) {
+ if (rm >= 4)
+ return UD_R_SPL + (rm-4);
+ return UD_R_AL + rm;
+ } else return UD_R_AL + rm;
+ case 0:
+ /* invalid size in case of a decode error */
+ UD_ASSERT(u->error);
+ return UD_NONE;
+ default:
+ UD_ASSERT(!"invalid operand size");
+ return UD_NONE;
+ }
+}
+
+static void
+decode_reg(struct ud *u,
+ struct ud_operand *opr,
+ int type,
+ int num,
+ int size)
+{
+ int reg;
+ size = resolve_operand_size(u, size);
+ switch (type) {
+ case REGCLASS_GPR : reg = decode_gpr(u, size, num); break;
+ case REGCLASS_MMX : reg = UD_R_MM0 + (num & 7); break;
+ case REGCLASS_XMM : reg = UD_R_XMM0 + num; break;
+ case REGCLASS_CR : reg = UD_R_CR0 + num; break;
+ case REGCLASS_DB : reg = UD_R_DR0 + num; break;
+ case REGCLASS_SEG : {
+ /*
+ * Only 6 segment registers, anything else is an error.
+ */
+ if ((num & 7) > 5) {
+ UDERR(u, "invalid segment register value\n");
+ return;
+ } else {
+ reg = UD_R_ES + (num & 7);
+ }
+ break;
+ }
+ default:
+ UD_ASSERT(!"invalid register type");
+ return;
+ }
+ opr->type = UD_OP_REG;
+ opr->base = reg;
+ opr->size = size;
+}
+
+
+/*
+ * decode_imm
+ *
+ * Decode Immediate values.
+ */
+static void
+decode_imm(struct ud* u, unsigned int size, struct ud_operand *op)
+{
+ op->size = resolve_operand_size(u, size);
+ op->type = UD_OP_IMM;
+
+ switch (op->size) {
+ case 8: op->lval.sbyte = inp_uint8(u); break;
+ case 16: op->lval.uword = inp_uint16(u); break;
+ case 32: op->lval.udword = inp_uint32(u); break;
+ case 64: op->lval.uqword = inp_uint64(u); break;
+ default: return;
+ }
+}
+
+
+/*
+ * decode_mem_disp
+ *
+ * Decode mem address displacement.
+ */
+static void
+decode_mem_disp(struct ud* u, unsigned int size, struct ud_operand *op)
+{
+ switch (size) {
+ case 8:
+ op->offset = 8;
+ op->lval.ubyte = inp_uint8(u);
+ break;
+ case 16:
+ op->offset = 16;
+ op->lval.uword = inp_uint16(u);
+ break;
+ case 32:
+ op->offset = 32;
+ op->lval.udword = inp_uint32(u);
+ break;
+ case 64:
+ op->offset = 64;
+ op->lval.uqword = inp_uint64(u);
+ break;
+ default:
+ return;
+ }
+}
+
+
+/*
+ * decode_modrm_reg
+ *
+ * Decodes reg field of mod/rm byte
+ *
+ */
+static inline void
+decode_modrm_reg(struct ud *u,
+ struct ud_operand *operand,
+ unsigned int type,
+ unsigned int size)
+{
+ uint8_t reg = (REX_R(u->pfx_rex) << 3) | MODRM_REG(modrm(u));
+ decode_reg(u, operand, type, reg, size);
+}
+
+
+/*
+ * decode_modrm_rm
+ *
+ * Decodes rm field of mod/rm byte
+ *
+ */
+static void
+decode_modrm_rm(struct ud *u,
+ struct ud_operand *op,
+ unsigned char type, /* register type */
+ unsigned int size) /* operand size */
+
+{
+ size_t offset = 0;
+ unsigned char mod, rm;
+
+ /* get mod, r/m and reg fields */
+ mod = MODRM_MOD(modrm(u));
+ rm = (REX_B(u->pfx_rex) << 3) | MODRM_RM(modrm(u));
+
+ /*
+ * If mod is 11b, then the modrm.rm specifies a register.
+ *
+ */
+ if (mod == 3) {
+ decode_reg(u, op, type, rm, size);
+ return;
+ }
+
+ /*
+ * !11b => Memory Address
+ */
+ op->type = UD_OP_MEM;
+ op->size = resolve_operand_size(u, size);
+
+ if (u->adr_mode == 64) {
+ op->base = UD_R_RAX + rm;
+ if (mod == 1) {
+ offset = 8;
+ } else if (mod == 2) {
+ offset = 32;
+ } else if (mod == 0 && (rm & 7) == 5) {
+ op->base = UD_R_RIP;
+ offset = 32;
+ } else {
+ offset = 0;
+ }
+ /*
+ * Scale-Index-Base (SIB)
+ */
+ if ((rm & 7) == 4) {
+ inp_next(u);
+
+ op->scale = (1 << SIB_S(inp_curr(u))) & ~1;
+ op->index = UD_R_RAX + (SIB_I(inp_curr(u)) | (REX_X(u->pfx_rex) << 3));
+ op->base = UD_R_RAX + (SIB_B(inp_curr(u)) | (REX_B(u->pfx_rex) << 3));
+
+ /* special conditions for base reference */
+ if (op->index == UD_R_RSP) {
+ op->index = UD_NONE;
+ op->scale = UD_NONE;
+ }
+
+ if (op->base == UD_R_RBP || op->base == UD_R_R13) {
+ if (mod == 0) {
+ op->base = UD_NONE;
+ }
+ if (mod == 1) {
+ offset = 8;
+ } else {
+ offset = 32;
+ }
+ }
+ }
+ } else if (u->adr_mode == 32) {
+ op->base = UD_R_EAX + rm;
+ if (mod == 1) {
+ offset = 8;
+ } else if (mod == 2) {
+ offset = 32;
+ } else if (mod == 0 && rm == 5) {
+ op->base = UD_NONE;
+ offset = 32;
+ } else {
+ offset = 0;
+ }
+
+ /* Scale-Index-Base (SIB) */
+ if ((rm & 7) == 4) {
+ inp_next(u);
+
+ op->scale = (1 << SIB_S(inp_curr(u))) & ~1;
+ op->index = UD_R_EAX + (SIB_I(inp_curr(u)) | (REX_X(u->pfx_rex) << 3));
+ op->base = UD_R_EAX + (SIB_B(inp_curr(u)) | (REX_B(u->pfx_rex) << 3));
+
+ if (op->index == UD_R_ESP) {
+ op->index = UD_NONE;
+ op->scale = UD_NONE;
+ }
+
+ /* special condition for base reference */
+ if (op->base == UD_R_EBP) {
+ if (mod == 0) {
+ op->base = UD_NONE;
+ }
+ if (mod == 1) {
+ offset = 8;
+ } else {
+ offset = 32;
+ }
+ }
+ }
+ } else {
+ const unsigned int bases[] = { UD_R_BX, UD_R_BX, UD_R_BP, UD_R_BP,
+ UD_R_SI, UD_R_DI, UD_R_BP, UD_R_BX };
+ const unsigned int indices[] = { UD_R_SI, UD_R_DI, UD_R_SI, UD_R_DI,
+ UD_NONE, UD_NONE, UD_NONE, UD_NONE };
+ op->base = bases[rm & 7];
+ op->index = indices[rm & 7];
+ if (mod == 0 && rm == 6) {
+ offset = 16;
+ op->base = UD_NONE;
+ } else if (mod == 1) {
+ offset = 8;
+ } else if (mod == 2) {
+ offset = 16;
+ }
+ }
+
+ if (offset) {
+ decode_mem_disp(u, offset, op);
+ }
+}
+
+
+/*
+ * decode_moffset
+ * Decode offset-only memory operand
+ */
+static void
+decode_moffset(struct ud *u, unsigned int size, struct ud_operand *opr)
+{
+ opr->type = UD_OP_MEM;
+ opr->size = resolve_operand_size(u, size);
+ decode_mem_disp(u, u->adr_mode, opr);
+}
+
+
+/*
-----------------------------------------------------------------------------
+ * decode_operands() - Disassembles Operands.
+ *
-----------------------------------------------------------------------------
+ */
+static int
+decode_operand(struct ud *u,
+ struct ud_operand *operand,
+ enum ud_operand_code type,
+ unsigned int size)
+{
+ operand->_oprcode = type;
+
+ switch (type) {
+ case OP_A :
+ decode_a(u, operand);
+ break;
+ case OP_MR:
+ decode_modrm_rm(u, operand, REGCLASS_GPR,
+ MODRM_MOD(modrm(u)) == 3 ?
+ Mx_reg_size(size) : Mx_mem_size(size));
+ break;
+ case OP_F:
+ u->br_far = 1;
+ /* intended fall through */
+ case OP_M:
+ if (MODRM_MOD(modrm(u)) == 3) {
+ UDERR(u, "expected modrm.mod != 3\n");
+ }
+ /* intended fall through */
+ case OP_E:
+ decode_modrm_rm(u, operand, REGCLASS_GPR, size);
+ break;
+ case OP_G:
+ decode_modrm_reg(u, operand, REGCLASS_GPR, size);
+ break;
+ case OP_sI:
+ case OP_I:
+ decode_imm(u, size, operand);
+ break;
+ case OP_I1:
+ operand->type = UD_OP_CONST;
+ operand->lval.udword = 1;
+ break;
+ case OP_N:
+ if (MODRM_MOD(modrm(u)) != 3) {
+ UDERR(u, "expected modrm.mod == 3\n");
+ }
+ /* intended fall through */
+ case OP_Q:
+ decode_modrm_rm(u, operand, REGCLASS_MMX, size);
+ break;
+ case OP_P:
+ decode_modrm_reg(u, operand, REGCLASS_MMX, size);
+ break;
+ case OP_U:
+ if (MODRM_MOD(modrm(u)) != 3) {
+ UDERR(u, "expected modrm.mod == 3\n");
+ }
+ /* intended fall through */
+ case OP_W:
+ decode_modrm_rm(u, operand, REGCLASS_XMM, size);
+ break;
+ case OP_V:
+ decode_modrm_reg(u, operand, REGCLASS_XMM, size);
+ break;
+ case OP_MU:
+ decode_modrm_rm(u, operand, REGCLASS_XMM,
+ MODRM_MOD(modrm(u)) == 3 ?
+ Mx_reg_size(size) : Mx_mem_size(size));
+ break;
+ case OP_S:
+ decode_modrm_reg(u, operand, REGCLASS_SEG, size);
+ break;
+ case OP_O:
+ decode_moffset(u, size, operand);
+ break;
+ case OP_R0:
+ case OP_R1:
+ case OP_R2:
+ case OP_R3:
+ case OP_R4:
+ case OP_R5:
+ case OP_R6:
+ case OP_R7:
+ decode_reg(u, operand, REGCLASS_GPR,
+ (REX_B(u->pfx_rex) << 3) | (type - OP_R0), size);
+ break;
+ case OP_AL:
+ case OP_AX:
+ case OP_eAX:
+ case OP_rAX:
+ decode_reg(u, operand, REGCLASS_GPR, 0, size);
+ break;
+ case OP_CL:
+ case OP_CX:
+ case OP_eCX:
+ decode_reg(u, operand, REGCLASS_GPR, 1, size);
+ break;
+ case OP_DL:
+ case OP_DX:
+ case OP_eDX:
+ decode_reg(u, operand, REGCLASS_GPR, 2, size);
+ break;
+ case OP_ES:
+ case OP_CS:
+ case OP_DS:
+ case OP_SS:
+ case OP_FS:
+ case OP_GS:
+ /* in 64bits mode, only fs and gs are allowed */
+ if (u->dis_mode == 64) {
+ if (type != OP_FS && type != OP_GS) {
+ UDERR(u, "invalid segment register in 64bits\n");
+ }
+ }
+ operand->type = UD_OP_REG;
+ operand->base = (type - OP_ES) + UD_R_ES;
+ operand->size = 16;
+ break;
+ case OP_J :
+ decode_imm(u, size, operand);
+ operand->type = UD_OP_JIMM;
+ break ;
+ case OP_R :
+ if (MODRM_MOD(modrm(u)) != 3) {
+ UDERR(u, "expected modrm.mod == 3\n");
+ }
+ decode_modrm_rm(u, operand, REGCLASS_GPR, size);
+ break;
+ case OP_C:
+ decode_modrm_reg(u, operand, REGCLASS_CR, size);
+ break;
+ case OP_D:
+ decode_modrm_reg(u, operand, REGCLASS_DB, size);
+ break;
+ case OP_I3 :
+ operand->type = UD_OP_CONST;
+ operand->lval.sbyte = 3;
+ break;
+ case OP_ST0:
+ case OP_ST1:
+ case OP_ST2:
+ case OP_ST3:
+ case OP_ST4:
+ case OP_ST5:
+ case OP_ST6:
+ case OP_ST7:
+ operand->type = UD_OP_REG;
+ operand->base = (type - OP_ST0) + UD_R_ST0;
+ operand->size = 80;
+ break;
+ default :
+ break;
+ }
+ return 0;
+}
+
+
+/*
+ * decode_operands
+ *
+ * Disassemble upto 3 operands of the current instruction being
+ * disassembled. By the end of the function, the operand fields
+ * of the ud structure will have been filled.
+ */
+static int
+decode_operands(struct ud* u)
+{
+ decode_operand(u, &u->operand[0],
+ u->itab_entry->operand1.type,
+ u->itab_entry->operand1.size);
+ decode_operand(u, &u->operand[1],
+ u->itab_entry->operand2.type,
+ u->itab_entry->operand2.size);
+ decode_operand(u, &u->operand[2],
+ u->itab_entry->operand3.type,
+ u->itab_entry->operand3.size);
+ return 0;
+}
+
+/*
-----------------------------------------------------------------------------
+ * clear_insn() - clear instruction structure
+ *
-----------------------------------------------------------------------------
+ */
+static void
+clear_insn(register struct ud* u)
+{
+ u->error = 0;
+ u->pfx_seg = 0;
+ u->pfx_opr = 0;
+ u->pfx_adr = 0;
+ u->pfx_lock = 0;
+ u->pfx_repne = 0;
+ u->pfx_rep = 0;
+ u->pfx_repe = 0;
+ u->pfx_rex = 0;
+ u->pfx_str = 0;
+ u->mnemonic = UD_Inone;
+ u->itab_entry = NULL;
+ u->have_modrm = 0;
+ u->br_far = 0;
+
+ memset( &u->operand[ 0 ], 0, sizeof( struct ud_operand ) );
+ memset( &u->operand[ 1 ], 0, sizeof( struct ud_operand ) );
+ memset( &u->operand[ 2 ], 0, sizeof( struct ud_operand ) );
+}
+
+
+static inline int
+resolve_pfx_str(struct ud* u)
+{
+ if (u->pfx_str == 0xf3) {
+ if (P_STR(u->itab_entry->prefix)) {
+ u->pfx_rep = 0xf3;
+ } else {
+ u->pfx_repe = 0xf3;
+ }
+ } else if (u->pfx_str == 0xf2) {
+ u->pfx_repne = 0xf3;
+ }
+ return 0;
+}
+
+
+static int
+resolve_mode( struct ud* u )
+{
+ int default64;
+ /* if in error state, bail out */
+ if ( u->error ) return -1;
+
+ /* propagate prefix effects */
+ if ( u->dis_mode == 64 ) { /* set 64bit-mode flags */
+
+ /* Check validity of instruction m64 */
+ if ( P_INV64( u->itab_entry->prefix ) ) {
+ UDERR(u, "instruction invalid in 64bits\n");
+ return -1;
+ }
+
+ /* effective rex prefix is the effective mask for the
+ * instruction hard-coded in the opcode map.
+ */
+ u->pfx_rex = ( u->pfx_rex & 0x40 ) |
+ ( u->pfx_rex & REX_PFX_MASK( u->itab_entry->prefix ) );
+
+ /* whether this instruction has a default operand size of
+ * 64bit, also hardcoded into the opcode map.
+ */
+ default64 = P_DEF64( u->itab_entry->prefix );
+ /* calculate effective operand size */
+ if ( REX_W( u->pfx_rex ) ) {
+ u->opr_mode = 64;
+ } else if ( u->pfx_opr ) {
+ u->opr_mode = 16;
+ } else {
+ /* unless the default opr size of instruction is 64,
+ * the effective operand size in the absence of rex.w
+ * prefix is 32.
+ */
+ u->opr_mode = default64 ? 64 : 32;
+ }
+
+ /* calculate effective address size */
+ u->adr_mode = (u->pfx_adr) ? 32 : 64;
+ } else if ( u->dis_mode == 32 ) { /* set 32bit-mode flags */
+ u->opr_mode = ( u->pfx_opr ) ? 16 : 32;
+ u->adr_mode = ( u->pfx_adr ) ? 16 : 32;
+ } else if ( u->dis_mode == 16 ) { /* set 16bit-mode flags */
+ u->opr_mode = ( u->pfx_opr ) ? 32 : 16;
+ u->adr_mode = ( u->pfx_adr ) ? 32 : 16;
+ }
+
+ return 0;
+}
+
+
+static inline int
+decode_insn(struct ud *u, uint16_t ptr)
+{
+ UD_ASSERT((ptr & 0x8000) == 0);
+ u->itab_entry = &ud_itab[ ptr ];
+ u->mnemonic = u->itab_entry->mnemonic;
+ return (resolve_pfx_str(u) == 0 &&
+ resolve_mode(u) == 0 &&
+ decode_operands(u) == 0 &&
+ resolve_mnemonic(u) == 0) ? 0 : -1;
+}
+
+
+/*
+ * decode_3dnow()
+ *
+ * Decoding 3dnow is a little tricky because of its strange opcode
+ * structure. The final opcode disambiguation depends on the last
+ * byte that comes after the operands have been decoded. Fortunately,
+ * all 3dnow instructions have the same set of operand types. So we
+ * go ahead and decode the instruction by picking an arbitrarily chosen
+ * valid entry in the table, decode the operands, and read the final
+ * byte to resolve the menmonic.
+ */
+static inline int
+decode_3dnow(struct ud* u)
+{
+ uint16_t ptr;
+ UD_ASSERT(u->le->type == UD_TAB__OPC_3DNOW);
+ UD_ASSERT(u->le->table[0xc] != 0);
+ decode_insn(u, u->le->table[0xc]);
+ inp_next(u);
+ if (u->error) {
+ return -1;
+ }
+ ptr = u->le->table[inp_curr(u)];
+ UD_ASSERT((ptr & 0x8000) == 0);
+ u->mnemonic = ud_itab[ptr].mnemonic;
+ return 0;
+}
+
+
+static int
+decode_ssepfx(struct ud *u)
+{
+ uint8_t idx;
+ uint8_t pfx;
+
+ /*
+ * String prefixes (f2, f3) take precedence over operand
+ * size prefix (66).
+ */
+ pfx = u->pfx_str;
+ if (pfx == 0) {
+ pfx = u->pfx_opr;
+ }
+ idx = ((pfx & 0xf) + 1) / 2;
+ if (u->le->table[idx] == 0) {
+ idx = 0;
+ }
+ if (idx && u->le->table[idx] != 0) {
+ /*
+ * "Consume" the prefix as a part of the opcode, so it is no
+ * longer exported as an instruction prefix.
+ */
+ u->pfx_str = 0;
+ if (pfx == 0x66) {
+ /*
+ * consume "66" only if it was used for decoding, leaving
+ * it to be used as an operands size override for some
+ * simd instructions.
+ */
+ u->pfx_opr = 0;
+ }
+ }
+ return decode_ext(u, u->le->table[idx]);
+}
+
+
+/*
+ * decode_ext()
+ *
+ * Decode opcode extensions (if any)
+ */
+static int
+decode_ext(struct ud *u, uint16_t ptr)
+{
+ uint8_t idx = 0;
+ if ((ptr & 0x8000) == 0) {
+ return decode_insn(u, ptr);
+ }
+ u->le = &ud_lookup_table_list[(~0x8000 & ptr)];
+ if (u->le->type == UD_TAB__OPC_3DNOW) {
+ return decode_3dnow(u);
+ }
+
+ switch (u->le->type) {
+ case UD_TAB__OPC_MOD:
+ /* !11 = 0, 11 = 1 */
+ idx = (MODRM_MOD(modrm(u)) + 1) / 4;
+ break;
+ /* disassembly mode/operand size/address size based tables.
+ * 16 = 0,, 32 = 1, 64 = 2
+ */
+ case UD_TAB__OPC_MODE:
+ idx = u->dis_mode != 64 ? 0 : 1;
+ break;
+ case UD_TAB__OPC_OSIZE:
+ idx = eff_opr_mode(u->dis_mode, REX_W(u->pfx_rex), u->pfx_opr) / 32;
+ break;
+ case UD_TAB__OPC_ASIZE:
+ idx = eff_adr_mode(u->dis_mode, u->pfx_adr) / 32;
+ break;
+ case UD_TAB__OPC_X87:
+ idx = modrm(u) - 0xC0;
+ break;
+ case UD_TAB__OPC_VENDOR:
+ if (u->vendor == UD_VENDOR_ANY) {
+ /* choose a valid entry */
+ idx = (u->le->table[idx] != 0) ? 0 : 1;
+ } else if (u->vendor == UD_VENDOR_AMD) {
+ idx = 0;
+ } else {
+ idx = 1;
+ }
+ break;
+ case UD_TAB__OPC_RM:
+ idx = MODRM_RM(modrm(u));
+ break;
+ case UD_TAB__OPC_REG:
+ idx = MODRM_REG(modrm(u));
+ break;
+ case UD_TAB__OPC_SSE:
+ return decode_ssepfx(u);
+ default:
+ UD_ASSERT(!"not reached");
+ break;
+ }
+
+ return decode_ext(u, u->le->table[idx]);
+}
+
+
+static int
+decode_opcode(struct ud *u)
+{
+ uint16_t ptr;
+ UD_ASSERT(u->le->type == UD_TAB__OPC_TABLE);
+ UD_RETURN_ON_ERROR(u);
+ u->primary_opcode = inp_curr(u);
+ ptr = u->le->table[inp_curr(u)];
+ if (ptr & 0x8000) {
+ u->le = &ud_lookup_table_list[ptr & ~0x8000];
+ if (u->le->type == UD_TAB__OPC_TABLE) {
+ inp_next(u);
+ return decode_opcode(u);
+ }
+ }
+ return decode_ext(u, ptr);
+}
+
+
+/*
=============================================================================
+ * ud_decode() - Instruction decoder. Returns the number of bytes decoded.
+ *
=============================================================================
+ */
+unsigned int
+ud_decode(struct ud *u)
+{
+ inp_start(u);
+ clear_insn(u);
+ u->le = &ud_lookup_table_list[0];
+ u->error = decode_prefixes(u) == -1 ||
+ decode_opcode(u) == -1 ||
+ u->error;
+ /* Handle decode error. */
+ if (u->error) {
+ /* clear out the decode data. */
+ clear_insn(u);
+ /* mark the sequence of bytes as invalid. */
+ u->itab_entry = &ud_itab[0]; /* entry 0 is invalid */
+ u->mnemonic = u->itab_entry->mnemonic;
+ }
+
+ /* maybe this stray segment override byte
+ * should be spewed out?
+ */
+ if ( !P_SEG( u->itab_entry->prefix ) &&
+ u->operand[0].type != UD_OP_MEM &&
+ u->operand[1].type != UD_OP_MEM )
+ u->pfx_seg = 0;
+
+ u->insn_offset = u->pc; /* set offset of instruction */
+ u->asm_buf_fill = 0; /* set translation buffer index to 0 */
+ u->pc += u->inp_ctr; /* move program counter by bytes decoded */
+
+ /* return number of bytes disassembled. */
+ return u->inp_ctr;
+}
+
+/*
+vim: set ts=2 sw=2 expandtab
+*/
diff --git a/winsup/cygwin/udis86/decode.h b/winsup/cygwin/udis86/decode.h
new file mode 100644
index 000000000..a7362c84a
--- /dev/null
+++ b/winsup/cygwin/udis86/decode.h
@@ -0,0 +1,195 @@
+/* udis86 - libudis86/decode.h
+ *
+ * Copyright (c) 2002-2009 Vivek Thampi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
notice,
+ * this list of conditions and the following disclaimer in the
documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef UD_DECODE_H
+#define UD_DECODE_H
+
+#include "types.h"
+#include "itab.h"
+
+#define MAX_INSN_LENGTH 15
+
+/* itab prefix bits */
+#define P_none ( 0 )
+#define P_cast ( 1 << 0 )
+#define P_CAST(n) ( ( n >> 0 ) & 1 )
+#define P_rexb ( 1 << 1 )
+#define P_REXB(n) ( ( n >> 1 ) & 1 )
+#define P_inv64 ( 1 << 4 )
+#define P_INV64(n) ( ( n >> 4 ) & 1 )
+#define P_rexw ( 1 << 5 )
+#define P_REXW(n) ( ( n >> 5 ) & 1 )
+#define P_def64 ( 1 << 7 )
+#define P_DEF64(n) ( ( n >> 7 ) & 1 )
+#define P_rexr ( 1 << 8 )
+#define P_REXR(n) ( ( n >> 8 ) & 1 )
+#define P_oso ( 1 << 9 )
+#define P_OSO(n) ( ( n >> 9 ) & 1 )
+#define P_aso ( 1 << 10 )
+#define P_ASO(n) ( ( n >> 10 ) & 1 )
+#define P_rexx ( 1 << 11 )
+#define P_REXX(n) ( ( n >> 11 ) & 1 )
+#define P_ImpAddr ( 1 << 12 )
+#define P_IMPADDR(n) ( ( n >> 12 ) & 1 )
+#define P_seg ( 1 << 13 )
+#define P_SEG(n) ( ( n >> 13 ) & 1 )
+#define P_str ( 1 << 14 )
+#define P_STR(n) ( ( n >> 14 ) & 1 )
+#define P_strz ( 1 << 15 )
+#define P_STR_ZF(n) ( ( n >> 15 ) & 1 )
+
+/* operand type constants -- order is important! */
+
+enum ud_operand_code {
+ OP_NONE,
+
+ OP_A, OP_E, OP_M, OP_G,
+ OP_I, OP_F,
+
+ OP_R0, OP_R1, OP_R2, OP_R3,
+ OP_R4, OP_R5, OP_R6, OP_R7,
+
+ OP_AL, OP_CL, OP_DL,
+ OP_AX, OP_CX, OP_DX,
+ OP_eAX, OP_eCX, OP_eDX,
+ OP_rAX, OP_rCX, OP_rDX,
+
+ OP_ES, OP_CS, OP_SS, OP_DS,
+ OP_FS, OP_GS,
+
+ OP_ST0, OP_ST1, OP_ST2, OP_ST3,
+ OP_ST4, OP_ST5, OP_ST6, OP_ST7,
+
+ OP_J, OP_S, OP_O,
+ OP_I1, OP_I3, OP_sI,
+
+ OP_V, OP_W, OP_Q, OP_P,
+ OP_U, OP_N, OP_MU,
+
+ OP_R, OP_C, OP_D,
+
+ OP_MR
+} UD_ATTR_PACKED;
+
+
+/* operand size constants */
+
+enum ud_operand_size {
+ SZ_NA = 0,
+ SZ_Z = 1,
+ SZ_V = 2,
+ SZ_RDQ = 7,
+
+ /* the following values are used as is,
+ * and thus hard-coded. changing them
+ * will break internals
+ */
+ SZ_B = 8,
+ SZ_W = 16,
+ SZ_D = 32,
+ SZ_Q = 64,
+ SZ_T = 80,
+ SZ_O = 128,
+
+ SZ_Y = 17,
+
+ /*
+ * complex size types, that encode sizes for operands
+ * of type MR (memory or register), for internal use
+ * only. Id space 256 and above.
+ */
+ SZ_BD = (SZ_B << 8) | SZ_D,
+ SZ_BV = (SZ_B << 8) | SZ_V,
+ SZ_WD = (SZ_W << 8) | SZ_D,
+ SZ_WV = (SZ_W << 8) | SZ_V,
+ SZ_WY = (SZ_W << 8) | SZ_Y,
+ SZ_DY = (SZ_D << 8) | SZ_Y,
+ SZ_WO = (SZ_W << 8) | SZ_O,
+ SZ_DO = (SZ_D << 8) | SZ_O,
+ SZ_QO = (SZ_Q << 8) | SZ_O,
+
+} UD_ATTR_PACKED;
+
+
+/* resolve complex size type.
+ */
+static inline enum ud_operand_size
+Mx_mem_size(enum ud_operand_size size)
+{
+ return (size >> 8) & 0xff;
+}
+
+static inline enum ud_operand_size
+Mx_reg_size(enum ud_operand_size size)
+{
+ return size & 0xff;
+}
+
+/* A single operand of an entry in the instruction table.
+ * (internal use only)
+ */
+struct ud_itab_entry_operand
+{
+ enum ud_operand_code type;
+ enum ud_operand_size size;
+};
+
+
+/* A single entry in an instruction table.
+ *(internal use only)
+ */
+struct ud_itab_entry
+{
+ enum ud_mnemonic_code mnemonic;
+ struct ud_itab_entry_operand operand1;
+ struct ud_itab_entry_operand operand2;
+ struct ud_itab_entry_operand operand3;
+ uint32_t prefix;
+};
+
+struct ud_lookup_table_list_entry {
+ const uint16_t *table;
+ enum ud_table_type type;
+ const char *meta;
+};
+
+
+
+static inline int
+ud_opcode_field_sext(uint8_t primary_opcode)
+{
+ return (primary_opcode & 0x02) != 0;
+}
+
+extern struct ud_itab_entry ud_itab[];
+extern struct ud_lookup_table_list_entry ud_lookup_table_list[];
+
+#endif /* UD_DECODE_H */
+
+/* vim:cindent
+ * vim:expandtab
+ * vim:ts=4
+ * vim:sw=4
+ */
diff --git a/winsup/cygwin/udis86/extern.h b/winsup/cygwin/udis86/extern.h
new file mode 100644
index 000000000..ae9f82f22
--- /dev/null
+++ b/winsup/cygwin/udis86/extern.h
@@ -0,0 +1,105 @@
+/* udis86 - libudis86/extern.h
+ *
+ * Copyright (c) 2002-2009, 2013 Vivek Thampi
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
notice,
+ * this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
notice,
+ * this list of conditions and the following disclaimer in the
documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef UD_EXTERN_H
+#define UD_EXTERN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "types.h"
+
+/* ============================= PUBLIC API =================================
*/
+
+extern void ud_init(struct ud*);
+
+extern void ud_set_mode(struct ud*, uint8_t);
+
+extern void ud_set_pc(struct ud*, uint64_t);
+
+extern void ud_set_input_hook(struct ud*, int (*)(struct ud*));
+
+extern void ud_set_input_buffer(struct ud*, const uint8_t*, size_t);
+
+#ifndef __UD_STANDALONE__
+extern void ud_set_input_file(struct ud*, FILE*);
+#endif /* __UD_STANDALONE__ */
+
+extern void ud_set_vendor(struct ud*, unsigned);
+
+extern void ud_set_syntax(struct ud*, void (*)(struct ud*));
+
+extern void ud_input_skip(struct ud*, size_t);
+
+extern int ud_input_end(const struct ud*);
+
+extern unsigned int ud_decode(struct ud*);
+
+extern unsigned int ud_disassemble(struct ud*);
+
+extern void ud_translate_intel(struct ud*);
+
+extern void ud_translate_att(struct ud*);
+
+extern const char* ud_insn_asm(const struct ud* u);
+
+extern const uint8_t* ud_insn_ptr(const struct ud* u);
+
+extern uint64_t ud_insn_off(const struct ud*);
+
+extern const char* ud_insn_hex(struct ud*);
+
+extern unsigned int ud_insn_len(const struct ud* u);
+
+extern const struct ud_operand* ud_insn_opr(const struct ud *u, unsigned int
n);
+
+extern int ud_opr_is_sreg(const struct ud_operand *opr);
+
+extern int ud_opr_is_gpr(const struct ud_operand *opr);
+
+extern enum ud_mnemonic_code ud_insn_mnemonic(const struct ud *u);
+
+extern const char* ud_lookup_mnemonic(enum ud_mnemonic_code c);
+
+extern void ud_set_user_opaque_data(struct ud*, void*);
+
+extern void* ud_get_user_opaque_data(const struct ud*);
+
+extern uint64_t ud_insn_sext_imm(const struct ud*, const struct ud_operand*);
+
+extern void ud_set_asm_buffer(struct ud *u, char *buf, size_t size);
+
+extern void ud_set_sym_resolver(struct ud *u,
+ const char* (*resolver)(struct ud*,
+ uint64_t addr,
+ int64_t *offset));
+
+/* ==========================================================================
*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* UD_EXTERN_H */
diff --git a/winsup/cygwin/udis86/itab.c b/winsup/cygwin/udis86/itab.c
new file mode 100644
index 000000000..a3d0634b8
--- /dev/null
+++ b/winsup/cygwin/udis86/itab.c
@@ -0,0 +1,8401 @@
+/* itab.c -- generated by udis86:scripts/ud_itab.py, do no edit */
+#include "decode.h"
+
+#define GROUP(n) (0x8000 | (n))
+
+
+static const uint16_t ud_itab__1[] = {
+ /* 0 */ 7, 0,
+};
+
+static const uint16_t ud_itab__2[] = {
+ /* 0 */ 8, 0,
+};
+
+static const uint16_t ud_itab__3[] = {
+ /* 0 */ 15, 0,
+};
+
+static const uint16_t ud_itab__6[] = {
+ /* 0 */ 16, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__7[] = {
+ /* 0 */ 17, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__8[] = {
+ /* 0 */ 18, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__9[] = {
+ /* 0 */ 19, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__10[] = {
+ /* 0 */ 20, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__11[] = {
+ /* 0 */ 21, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__5[] = {
+ /* 0 */ GROUP(6), GROUP(7), GROUP(8), GROUP(9),
+ /* 4 */ GROUP(10), GROUP(11), 0, 0,
+};
+
+static const uint16_t ud_itab__15[] = {
+ /* 0 */ 22, 0,
+};
+
+static const uint16_t ud_itab__14[] = {
+ /* 0 */ GROUP(15), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__17[] = {
+ /* 0 */ 23, 0,
+};
+
+static const uint16_t ud_itab__16[] = {
+ /* 0 */ GROUP(17), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__19[] = {
+ /* 0 */ 24, 0,
+};
+
+static const uint16_t ud_itab__18[] = {
+ /* 0 */ GROUP(19), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__21[] = {
+ /* 0 */ 25, 0,
+};
+
+static const uint16_t ud_itab__20[] = {
+ /* 0 */ GROUP(21), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__23[] = {
+ /* 0 */ 26, 0,
+};
+
+static const uint16_t ud_itab__22[] = {
+ /* 0 */ GROUP(23), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__25[] = {
+ /* 0 */ 27, 0,
+};
+
+static const uint16_t ud_itab__24[] = {
+ /* 0 */ GROUP(25), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__27[] = {
+ /* 0 */ 28, 0,
+};
+
+static const uint16_t ud_itab__26[] = {
+ /* 0 */ GROUP(27), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__13[] = {
+ /* 0 */ GROUP(14), GROUP(16), GROUP(18), GROUP(20),
+ /* 4 */ GROUP(22), 0, GROUP(24), GROUP(26),
+};
+
+static const uint16_t ud_itab__32[] = {
+ /* 0 */ 0, 29, 0,
+};
+
+static const uint16_t ud_itab__31[] = {
+ /* 0 */ 0, GROUP(32),
+};
+
+static const uint16_t ud_itab__30[] = {
+ /* 0 */ GROUP(31), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__35[] = {
+ /* 0 */ 0, 30, 0,
+};
+
+static const uint16_t ud_itab__34[] = {
+ /* 0 */ 0, GROUP(35),
+};
+
+static const uint16_t ud_itab__33[] = {
+ /* 0 */ GROUP(34), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__38[] = {
+ /* 0 */ 0, 31, 0,
+};
+
+static const uint16_t ud_itab__37[] = {
+ /* 0 */ 0, GROUP(38),
+};
+
+static const uint16_t ud_itab__36[] = {
+ /* 0 */ GROUP(37), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__41[] = {
+ /* 0 */ 0, 32, 0,
+};
+
+static const uint16_t ud_itab__40[] = {
+ /* 0 */ 0, GROUP(41),
+};
+
+static const uint16_t ud_itab__39[] = {
+ /* 0 */ GROUP(40), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__29[] = {
+ /* 0 */ 0, GROUP(30), GROUP(33), GROUP(36),
+ /* 4 */ GROUP(39), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__44[] = {
+ /* 0 */ 0, 33,
+};
+
+static const uint16_t ud_itab__43[] = {
+ /* 0 */ GROUP(44), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__46[] = {
+ /* 0 */ 0, 34,
+};
+
+static const uint16_t ud_itab__45[] = {
+ /* 0 */ GROUP(46), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__42[] = {
+ /* 0 */ GROUP(43), GROUP(45), 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__49[] = {
+ /* 0 */ 0, 35,
+};
+
+static const uint16_t ud_itab__48[] = {
+ /* 0 */ GROUP(49), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__51[] = {
+ /* 0 */ 0, 36,
+};
+
+static const uint16_t ud_itab__50[] = {
+ /* 0 */ GROUP(51), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__47[] = {
+ /* 0 */ GROUP(48), GROUP(50), 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__55[] = {
+ /* 0 */ 37, 0, 0,
+};
+
+static const uint16_t ud_itab__54[] = {
+ /* 0 */ 0, GROUP(55),
+};
+
+static const uint16_t ud_itab__53[] = {
+ /* 0 */ GROUP(54), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__58[] = {
+ /* 0 */ 38, 0, 0,
+};
+
+static const uint16_t ud_itab__57[] = {
+ /* 0 */ 0, GROUP(58),
+};
+
+static const uint16_t ud_itab__56[] = {
+ /* 0 */ GROUP(57), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__61[] = {
+ /* 0 */ 39, 0, 0,
+};
+
+static const uint16_t ud_itab__60[] = {
+ /* 0 */ 0, GROUP(61),
+};
+
+static const uint16_t ud_itab__59[] = {
+ /* 0 */ GROUP(60), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__64[] = {
+ /* 0 */ 40, 0, 0,
+};
+
+static const uint16_t ud_itab__63[] = {
+ /* 0 */ 0, GROUP(64),
+};
+
+static const uint16_t ud_itab__62[] = {
+ /* 0 */ GROUP(63), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__67[] = {
+ /* 0 */ 41, 0, 0,
+};
+
+static const uint16_t ud_itab__66[] = {
+ /* 0 */ 0, GROUP(67),
+};
+
+static const uint16_t ud_itab__65[] = {
+ /* 0 */ GROUP(66), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__70[] = {
+ /* 0 */ 42, 0, 0,
+};
+
+static const uint16_t ud_itab__69[] = {
+ /* 0 */ 0, GROUP(70),
+};
+
+static const uint16_t ud_itab__68[] = {
+ /* 0 */ GROUP(69), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__73[] = {
+ /* 0 */ 43, 0, 0,
+};
+
+static const uint16_t ud_itab__72[] = {
+ /* 0 */ 0, GROUP(73),
+};
+
+static const uint16_t ud_itab__71[] = {
+ /* 0 */ GROUP(72), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__76[] = {
+ /* 0 */ 44, 0, 0,
+};
+
+static const uint16_t ud_itab__75[] = {
+ /* 0 */ 0, GROUP(76),
+};
+
+static const uint16_t ud_itab__74[] = {
+ /* 0 */ GROUP(75), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__52[] = {
+ /* 0 */ GROUP(53), GROUP(56), GROUP(59), GROUP(62),
+ /* 4 */ GROUP(65), GROUP(68), GROUP(71), GROUP(74),
+};
+
+static const uint16_t ud_itab__78[] = {
+ /* 0 */ 0, 45,
+};
+
+static const uint16_t ud_itab__77[] = {
+ /* 0 */ GROUP(78), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__80[] = {
+ /* 0 */ 0, 46,
+};
+
+static const uint16_t ud_itab__79[] = {
+ /* 0 */ GROUP(80), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__83[] = {
+ /* 0 */ 0, 47,
+};
+
+static const uint16_t ud_itab__82[] = {
+ /* 0 */ GROUP(83), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__86[] = {
+ /* 0 */ 48, 0, 0,
+};
+
+static const uint16_t ud_itab__85[] = {
+ /* 0 */ 0, GROUP(86),
+};
+
+static const uint16_t ud_itab__84[] = {
+ /* 0 */ GROUP(85), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__81[] = {
+ /* 0 */ GROUP(82), GROUP(84), 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__28[] = {
+ /* 0 */ GROUP(29), GROUP(42), GROUP(47), GROUP(52),
+ /* 4 */ GROUP(77), 0, GROUP(79), GROUP(81),
+};
+
+static const uint16_t ud_itab__12[] = {
+ /* 0 */ GROUP(13), GROUP(28),
+};
+
+static const uint16_t ud_itab__87[] = {
+ /* 0 */ 49, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__88[] = {
+ /* 0 */ 50, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__89[] = {
+ /* 0 */ 51, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__90[] = {
+ /* 0 */ 52, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__91[] = {
+ /* 0 */ 53, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__92[] = {
+ /* 0 */ 54, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__93[] = {
+ /* 0 */ 55, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__94[] = {
+ /* 0 */ 56, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__96[] = {
+ /* 0 */ 57, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__97[] = {
+ /* 0 */ 58, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__98[] = {
+ /* 0 */ 59, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__99[] = {
+ /* 0 */ 60, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__100[] = {
+ /* 0 */ 61, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__101[] = {
+ /* 0 */ 62, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__102[] = {
+ /* 0 */ 63, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__103[] = {
+ /* 0 */ 64, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__95[] = {
+ /* 0 */ GROUP(96), GROUP(97), GROUP(98), GROUP(99),
+ /* 4 */ GROUP(100), GROUP(101), GROUP(102), GROUP(103),
+};
+
+static const uint16_t ud_itab__104[] = {
+ /* 0 */ 65, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__105[] = {
+ /* 0 */ 0, 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+ /* 8 */ 0, 0, 0, 0,
+ /* c */ 66, 67, 0, 0,
+ /* 10 */ 0, 0, 0, 0,
+ /* 14 */ 0, 0, 0, 0,
+ /* 18 */ 0, 0, 0, 0,
+ /* 1c */ 68, 69, 0, 0,
+ /* 20 */ 0, 0, 0, 0,
+ /* 24 */ 0, 0, 0, 0,
+ /* 28 */ 0, 0, 0, 0,
+ /* 2c */ 0, 0, 0, 0,
+ /* 30 */ 0, 0, 0, 0,
+ /* 34 */ 0, 0, 0, 0,
+ /* 38 */ 0, 0, 0, 0,
+ /* 3c */ 0, 0, 0, 0,
+ /* 40 */ 0, 0, 0, 0,
+ /* 44 */ 0, 0, 0, 0,
+ /* 48 */ 0, 0, 0, 0,
+ /* 4c */ 0, 0, 0, 0,
+ /* 50 */ 0, 0, 0, 0,
+ /* 54 */ 0, 0, 0, 0,
+ /* 58 */ 0, 0, 0, 0,
+ /* 5c */ 0, 0, 0, 0,
+ /* 60 */ 0, 0, 0, 0,
+ /* 64 */ 0, 0, 0, 0,
+ /* 68 */ 0, 0, 0, 0,
+ /* 6c */ 0, 0, 0, 0,
+ /* 70 */ 0, 0, 0, 0,
+ /* 74 */ 0, 0, 0, 0,
+ /* 78 */ 0, 0, 0, 0,
+ /* 7c */ 0, 0, 0, 0,
+ /* 80 */ 0, 0, 0, 0,
+ /* 84 */ 0, 0, 0, 0,
+ /* 88 */ 0, 0, 70, 0,
+ /* 8c */ 0, 0, 71, 0,
+ /* 90 */ 72, 0, 0, 0,
+ /* 94 */ 73, 0, 74, 75,
+ /* 98 */ 0, 0, 76, 0,
+ /* 9c */ 0, 0, 77, 0,
+ /* a0 */ 78, 0, 0, 0,
+ /* a4 */ 79, 0, 80, 81,
+ /* a8 */ 0, 0, 82, 0,
+ /* ac */ 0, 0, 83, 0,
+ /* b0 */ 84, 0, 0, 0,
+ /* b4 */ 85, 0, 86, 87,
+ /* b8 */ 0, 0, 0, 88,
+ /* bc */ 0, 0, 0, 89,
+ /* c0 */ 0, 0, 0, 0,
+ /* c4 */ 0, 0, 0, 0,
+ /* c8 */ 0, 0, 0, 0,
+ /* cc */ 0, 0, 0, 0,
+ /* d0 */ 0, 0, 0, 0,
+ /* d4 */ 0, 0, 0, 0,
+ /* d8 */ 0, 0, 0, 0,
+ /* dc */ 0, 0, 0, 0,
+ /* e0 */ 0, 0, 0, 0,
+ /* e4 */ 0, 0, 0, 0,
+ /* e8 */ 0, 0, 0, 0,
+ /* ec */ 0, 0, 0, 0,
+ /* f0 */ 0, 0, 0, 0,
+ /* f4 */ 0, 0, 0, 0,
+ /* f8 */ 0, 0, 0, 0,
+ /* fc */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__106[] = {
+ /* 0 */ 90, 91, 92, 93,
+};
+
+static const uint16_t ud_itab__107[] = {
+ /* 0 */ 94, 95, 96, 97,
+};
+
+static const uint16_t ud_itab__110[] = {
+ /* 0 */ 98, 0,
+};
+
+static const uint16_t ud_itab__111[] = {
+ /* 0 */ 99, 0,
+};
+
+static const uint16_t ud_itab__112[] = {
+ /* 0 */ 100, 0,
+};
+
+static const uint16_t ud_itab__113[] = {
+ /* 0 */ 101, 0,
+};
+
+static const uint16_t ud_itab__109[] = {
+ /* 0 */ GROUP(110), GROUP(111), GROUP(112), GROUP(113),
+};
+
+static const uint16_t ud_itab__115[] = {
+ /* 0 */ 0, 102,
+};
+
+static const uint16_t ud_itab__116[] = {
+ /* 0 */ 0, 103,
+};
+
+static const uint16_t ud_itab__117[] = {
+ /* 0 */ 0, 104,
+};
+
+static const uint16_t ud_itab__114[] = {
+ /* 0 */ GROUP(115), GROUP(116), GROUP(117), 0,
+};
+
+static const uint16_t ud_itab__108[] = {
+ /* 0 */ GROUP(109), GROUP(114),
+};
+
+static const uint16_t ud_itab__118[] = {
+ /* 0 */ 105, 0, 0, 106,
+};
+
+static const uint16_t ud_itab__119[] = {
+ /* 0 */ 107, 0, 0, 108,
+};
+
+static const uint16_t ud_itab__120[] = {
+ /* 0 */ 109, 0, 0, 110,
+};
+
+static const uint16_t ud_itab__123[] = {
+ /* 0 */ 111, 0,
+};
+
+static const uint16_t ud_itab__124[] = {
+ /* 0 */ 112, 0,
+};
+
+static const uint16_t ud_itab__125[] = {
+ /* 0 */ 113, 0,
+};
+
+static const uint16_t ud_itab__122[] = {
+ /* 0 */ GROUP(123), 0, GROUP(124), GROUP(125),
+};
+
+static const uint16_t ud_itab__127[] = {
+ /* 0 */ 0, 114,
+};
+
+static const uint16_t ud_itab__128[] = {
+ /* 0 */ 0, 115,
+};
+
+static const uint16_t ud_itab__126[] = {
+ /* 0 */ GROUP(127), 0, GROUP(128), 0,
+};
+
+static const uint16_t ud_itab__121[] = {
+ /* 0 */ GROUP(122), GROUP(126),
+};
+
+static const uint16_t ud_itab__129[] = {
+ /* 0 */ 116, 0, 0, 117,
+};
+
+static const uint16_t ud_itab__131[] = {
+ /* 0 */ 118, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__132[] = {
+ /* 0 */ 119, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__133[] = {
+ /* 0 */ 120, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__134[] = {
+ /* 0 */ 121, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__130[] = {
+ /* 0 */ GROUP(131), GROUP(132), GROUP(133), GROUP(134),
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__135[] = {
+ /* 0 */ 122, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__136[] = {
+ /* 0 */ 123, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__137[] = {
+ /* 0 */ 124, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__138[] = {
+ /* 0 */ 125, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__139[] = {
+ /* 0 */ 126, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__140[] = {
+ /* 0 */ 127, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__141[] = {
+ /* 0 */ 128, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__142[] = {
+ /* 0 */ 129, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__143[] = {
+ /* 0 */ 130, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__144[] = {
+ /* 0 */ 131, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__145[] = {
+ /* 0 */ 132, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__146[] = {
+ /* 0 */ 133, 0, 0, 134,
+};
+
+static const uint16_t ud_itab__147[] = {
+ /* 0 */ 135, 0, 0, 136,
+};
+
+static const uint16_t ud_itab__148[] = {
+ /* 0 */ 137, 138, 139, 140,
+};
+
+static const uint16_t ud_itab__149[] = {
+ /* 0 */ 141, 0, 0, 142,
+};
+
+static const uint16_t ud_itab__150[] = {
+ /* 0 */ 143, 144, 145, 146,
+};
+
+static const uint16_t ud_itab__151[] = {
+ /* 0 */ 147, 148, 149, 150,
+};
+
+static const uint16_t ud_itab__152[] = {
+ /* 0 */ 151, 0, 0, 152,
+};
+
+static const uint16_t ud_itab__153[] = {
+ /* 0 */ 153, 0, 0, 154,
+};
+
+static const uint16_t ud_itab__154[] = {
+ /* 0 */ 155, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__155[] = {
+ /* 0 */ 156, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__156[] = {
+ /* 0 */ 157, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__157[] = {
+ /* 0 */ 158, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__160[] = {
+ /* 0 */ 0, 160, 0,
+};
+
+static const uint16_t ud_itab__159[] = {
+ /* 0 */ 159, GROUP(160),
+};
+
+static const uint16_t ud_itab__158[] = {
+ /* 0 */ GROUP(159), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__163[] = {
+ /* 0 */ 0, 162, 0,
+};
+
+static const uint16_t ud_itab__162[] = {
+ /* 0 */ 161, GROUP(163),
+};
+
+static const uint16_t ud_itab__161[] = {
+ /* 0 */ GROUP(162), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__164[] = {
+ /* 0 */ 163, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__166[] = {
+ /* 0 */ 164, 0, 0, 165,
+};
+
+static const uint16_t ud_itab__167[] = {
+ /* 0 */ 166, 0, 0, 167,
+};
+
+static const uint16_t ud_itab__168[] = {
+ /* 0 */ 168, 0, 0, 169,
+};
+
+static const uint16_t ud_itab__169[] = {
+ /* 0 */ 170, 0, 0, 171,
+};
+
+static const uint16_t ud_itab__170[] = {
+ /* 0 */ 172, 0, 0, 173,
+};
+
+static const uint16_t ud_itab__171[] = {
+ /* 0 */ 174, 0, 0, 175,
+};
+
+static const uint16_t ud_itab__172[] = {
+ /* 0 */ 176, 0, 0, 177,
+};
+
+static const uint16_t ud_itab__173[] = {
+ /* 0 */ 178, 0, 0, 179,
+};
+
+static const uint16_t ud_itab__174[] = {
+ /* 0 */ 180, 0, 0, 181,
+};
+
+static const uint16_t ud_itab__175[] = {
+ /* 0 */ 182, 0, 0, 183,
+};
+
+static const uint16_t ud_itab__176[] = {
+ /* 0 */ 184, 0, 0, 185,
+};
+
+static const uint16_t ud_itab__177[] = {
+ /* 0 */ 186, 0, 0, 187,
+};
+
+static const uint16_t ud_itab__178[] = {
+ /* 0 */ 0, 0, 0, 188,
+};
+
+static const uint16_t ud_itab__179[] = {
+ /* 0 */ 0, 0, 0, 189,
+};
+
+static const uint16_t ud_itab__180[] = {
+ /* 0 */ 0, 0, 0, 190,
+};
+
+static const uint16_t ud_itab__181[] = {
+ /* 0 */ 0, 0, 0, 191,
+};
+
+static const uint16_t ud_itab__182[] = {
+ /* 0 */ 192, 0, 0, 193,
+};
+
+static const uint16_t ud_itab__183[] = {
+ /* 0 */ 194, 0, 0, 195,
+};
+
+static const uint16_t ud_itab__184[] = {
+ /* 0 */ 196, 0, 0, 197,
+};
+
+static const uint16_t ud_itab__185[] = {
+ /* 0 */ 0, 0, 0, 198,
+};
+
+static const uint16_t ud_itab__186[] = {
+ /* 0 */ 0, 0, 0, 199,
+};
+
+static const uint16_t ud_itab__187[] = {
+ /* 0 */ 0, 0, 0, 200,
+};
+
+static const uint16_t ud_itab__188[] = {
+ /* 0 */ 0, 0, 0, 201,
+};
+
+static const uint16_t ud_itab__189[] = {
+ /* 0 */ 0, 0, 0, 202,
+};
+
+static const uint16_t ud_itab__190[] = {
+ /* 0 */ 0, 0, 0, 203,
+};
+
+static const uint16_t ud_itab__191[] = {
+ /* 0 */ 0, 0, 0, 204,
+};
+
+static const uint16_t ud_itab__192[] = {
+ /* 0 */ 0, 0, 0, 205,
+};
+
+static const uint16_t ud_itab__193[] = {
+ /* 0 */ 0, 0, 0, 206,
+};
+
+static const uint16_t ud_itab__194[] = {
+ /* 0 */ 0, 0, 0, 207,
+};
+
+static const uint16_t ud_itab__195[] = {
+ /* 0 */ 0, 0, 0, 208,
+};
+
+static const uint16_t ud_itab__196[] = {
+ /* 0 */ 0, 0, 0, 209,
+};
+
+static const uint16_t ud_itab__197[] = {
+ /* 0 */ 0, 0, 0, 210,
+};
+
+static const uint16_t ud_itab__198[] = {
+ /* 0 */ 0, 0, 0, 211,
+};
+
+static const uint16_t ud_itab__199[] = {
+ /* 0 */ 0, 0, 0, 212,
+};
+
+static const uint16_t ud_itab__200[] = {
+ /* 0 */ 0, 0, 0, 213,
+};
+
+static const uint16_t ud_itab__201[] = {
+ /* 0 */ 0, 0, 0, 214,
+};
+
+static const uint16_t ud_itab__202[] = {
+ /* 0 */ 0, 0, 0, 215,
+};
+
+static const uint16_t ud_itab__203[] = {
+ /* 0 */ 0, 0, 0, 216,
+};
+
+static const uint16_t ud_itab__204[] = {
+ /* 0 */ 0, 0, 0, 217,
+};
+
+static const uint16_t ud_itab__205[] = {
+ /* 0 */ 0, 0, 0, 218,
+};
+
+static const uint16_t ud_itab__206[] = {
+ /* 0 */ 0, 0, 0, 219,
+};
+
+static const uint16_t ud_itab__207[] = {
+ /* 0 */ 0, 0, 0, 220,
+};
+
+static const uint16_t ud_itab__208[] = {
+ /* 0 */ 0, 0, 0, 221,
+};
+
+static const uint16_t ud_itab__209[] = {
+ /* 0 */ 0, 0, 0, 222,
+};
+
+static const uint16_t ud_itab__210[] = {
+ /* 0 */ 0, 0, 0, 223,
+};
+
+static const uint16_t ud_itab__211[] = {
+ /* 0 */ 0, 0, 0, 224,
+};
+
+static const uint16_t ud_itab__214[] = {
+ /* 0 */ 0, 225, 0,
+};
+
+static const uint16_t ud_itab__213[] = {
+ /* 0 */ 0, GROUP(214),
+};
+
+static const uint16_t ud_itab__212[] = {
+ /* 0 */ 0, 0, 0, GROUP(213),
+};
+
+static const uint16_t ud_itab__217[] = {
+ /* 0 */ 0, 226, 0,
+};
+
+static const uint16_t ud_itab__216[] = {
+ /* 0 */ 0, GROUP(217),
+};
+
+static const uint16_t ud_itab__215[] = {
+ /* 0 */ 0, 0, 0, GROUP(216),
+};
+
+static const uint16_t ud_itab__218[] = {
+ /* 0 */ 0, 0, 0, 227,
+};
+
+static const uint16_t ud_itab__219[] = {
+ /* 0 */ 0, 0, 0, 228,
+};
+
+static const uint16_t ud_itab__220[] = {
+ /* 0 */ 0, 0, 0, 229,
+};
+
+static const uint16_t ud_itab__221[] = {
+ /* 0 */ 0, 0, 0, 230,
+};
+
+static const uint16_t ud_itab__222[] = {
+ /* 0 */ 0, 0, 0, 231,
+};
+
+static const uint16_t ud_itab__223[] = {
+ /* 0 */ 232, 233, 0, 0,
+};
+
+static const uint16_t ud_itab__224[] = {
+ /* 0 */ 234, 235, 0, 0,
+};
+
+static const uint16_t ud_itab__165[] = {
+ /* 0 */ GROUP(166), GROUP(167), GROUP(168), GROUP(169),
+ /* 4 */ GROUP(170), GROUP(171), GROUP(172), GROUP(173),
+ /* 8 */ GROUP(174), GROUP(175), GROUP(176), GROUP(177),
+ /* c */ 0, 0, 0, 0,
+ /* 10 */ GROUP(178), 0, 0, 0,
+ /* 14 */ GROUP(179), GROUP(180), 0, GROUP(181),
+ /* 18 */ 0, 0, 0, 0,
+ /* 1c */ GROUP(182), GROUP(183), GROUP(184), 0,
+ /* 20 */ GROUP(185), GROUP(186), GROUP(187), GROUP(188),
+ /* 24 */ GROUP(189), GROUP(190), 0, 0,
+ /* 28 */ GROUP(191), GROUP(192), GROUP(193), GROUP(194),
+ /* 2c */ 0, 0, 0, 0,
+ /* 30 */ GROUP(195), GROUP(196), GROUP(197), GROUP(198),
+ /* 34 */ GROUP(199), GROUP(200), 0, GROUP(201),
+ /* 38 */ GROUP(202), GROUP(203), GROUP(204), GROUP(205),
+ /* 3c */ GROUP(206), GROUP(207), GROUP(208), GROUP(209),
+ /* 40 */ GROUP(210), GROUP(211), 0, 0,
+ /* 44 */ 0, 0, 0, 0,
+ /* 48 */ 0, 0, 0, 0,
+ /* 4c */ 0, 0, 0, 0,
+ /* 50 */ 0, 0, 0, 0,
+ /* 54 */ 0, 0, 0, 0,
+ /* 58 */ 0, 0, 0, 0,
+ /* 5c */ 0, 0, 0, 0,
+ /* 60 */ 0, 0, 0, 0,
+ /* 64 */ 0, 0, 0, 0,
+ /* 68 */ 0, 0, 0, 0,
+ /* 6c */ 0, 0, 0, 0,
+ /* 70 */ 0, 0, 0, 0,
+ /* 74 */ 0, 0, 0, 0,
+ /* 78 */ 0, 0, 0, 0,
+ /* 7c */ 0, 0, 0, 0,
+ /* 80 */ GROUP(212), GROUP(215), 0, 0,
+ /* 84 */ 0, 0, 0, 0,
+ /* 88 */ 0, 0, 0, 0,
+ /* 8c */ 0, 0, 0, 0,
+ /* 90 */ 0, 0, 0, 0,
+ /* 94 */ 0, 0, 0, 0,
+ /* 98 */ 0, 0, 0, 0,
+ /* 9c */ 0, 0, 0, 0,
+ /* a0 */ 0, 0, 0, 0,
+ /* a4 */ 0, 0, 0, 0,
+ /* a8 */ 0, 0, 0, 0,
+ /* ac */ 0, 0, 0, 0,
+ /* b0 */ 0, 0, 0, 0,
+ /* b4 */ 0, 0, 0, 0,
+ /* b8 */ 0, 0, 0, 0,
+ /* bc */ 0, 0, 0, 0,
+ /* c0 */ 0, 0, 0, 0,
+ /* c4 */ 0, 0, 0, 0,
+ /* c8 */ 0, 0, 0, 0,
+ /* cc */ 0, 0, 0, 0,
+ /* d0 */ 0, 0, 0, 0,
+ /* d4 */ 0, 0, 0, 0,
+ /* d8 */ 0, 0, 0, GROUP(218),
+ /* dc */ GROUP(219), GROUP(220), GROUP(221), GROUP(222),
+ /* e0 */ 0, 0, 0, 0,
+ /* e4 */ 0, 0, 0, 0,
+ /* e8 */ 0, 0, 0, 0,
+ /* ec */ 0, 0, 0, 0,
+ /* f0 */ GROUP(223), GROUP(224), 0, 0,
+ /* f4 */ 0, 0, 0, 0,
+ /* f8 */ 0, 0, 0, 0,
+ /* fc */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__226[] = {
+ /* 0 */ 0, 0, 0, 236,
+};
+
+static const uint16_t ud_itab__227[] = {
+ /* 0 */ 0, 0, 0, 237,
+};
+
+static const uint16_t ud_itab__228[] = {
+ /* 0 */ 0, 0, 0, 238,
+};
+
+static const uint16_t ud_itab__229[] = {
+ /* 0 */ 0, 0, 0, 239,
+};
+
+static const uint16_t ud_itab__230[] = {
+ /* 0 */ 0, 0, 0, 240,
+};
+
+static const uint16_t ud_itab__231[] = {
+ /* 0 */ 0, 0, 0, 241,
+};
+
+static const uint16_t ud_itab__232[] = {
+ /* 0 */ 0, 0, 0, 242,
+};
+
+static const uint16_t ud_itab__233[] = {
+ /* 0 */ 243, 0, 0, 244,
+};
+
+static const uint16_t ud_itab__234[] = {
+ /* 0 */ 0, 0, 0, 245,
+};
+
+static const uint16_t ud_itab__235[] = {
+ /* 0 */ 0, 0, 0, 246,
+};
+
+static const uint16_t ud_itab__237[] = {
+ /* 0 */ 247, 248, 249,
+};
+
+static const uint16_t ud_itab__236[] = {
+ /* 0 */ 0, 0, 0, GROUP(237),
+};
+
+static const uint16_t ud_itab__238[] = {
+ /* 0 */ 0, 0, 0, 250,
+};
+
+static const uint16_t ud_itab__239[] = {
+ /* 0 */ 0, 0, 0, 251,
+};
+
+static const uint16_t ud_itab__240[] = {
+ /* 0 */ 0, 0, 0, 252,
+};
+
+static const uint16_t ud_itab__242[] = {
+ /* 0 */ 253, 254, 255,
+};
+
+static const uint16_t ud_itab__241[] = {
+ /* 0 */ 0, 0, 0, GROUP(242),
+};
+
+static const uint16_t ud_itab__243[] = {
+ /* 0 */ 0, 0, 0, 256,
+};
+
+static const uint16_t ud_itab__244[] = {
+ /* 0 */ 0, 0, 0, 257,
+};
+
+static const uint16_t ud_itab__245[] = {
+ /* 0 */ 0, 0, 0, 258,
+};
+
+static const uint16_t ud_itab__246[] = {
+ /* 0 */ 0, 0, 0, 259,
+};
+
+static const uint16_t ud_itab__247[] = {
+ /* 0 */ 0, 0, 0, 260,
+};
+
+static const uint16_t ud_itab__248[] = {
+ /* 0 */ 0, 0, 0, 261,
+};
+
+static const uint16_t ud_itab__249[] = {
+ /* 0 */ 0, 0, 0, 262,
+};
+
+static const uint16_t ud_itab__250[] = {
+ /* 0 */ 0, 0, 0, 263,
+};
+
+static const uint16_t ud_itab__251[] = {
+ /* 0 */ 0, 0, 0, 264,
+};
+
+static const uint16_t ud_itab__225[] = {
+ /* 0 */ 0, 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+ /* 8 */ GROUP(226), GROUP(227), GROUP(228), GROUP(229),
+ /* c */ GROUP(230), GROUP(231), GROUP(232), GROUP(233),
+ /* 10 */ 0, 0, 0, 0,
+ /* 14 */ GROUP(234), GROUP(235), GROUP(236), GROUP(238),
+ /* 18 */ 0, 0, 0, 0,
+ /* 1c */ 0, 0, 0, 0,
+ /* 20 */ GROUP(239), GROUP(240), GROUP(241), 0,
+ /* 24 */ 0, 0, 0, 0,
+ /* 28 */ 0, 0, 0, 0,
+ /* 2c */ 0, 0, 0, 0,
+ /* 30 */ 0, 0, 0, 0,
+ /* 34 */ 0, 0, 0, 0,
+ /* 38 */ 0, 0, 0, 0,
+ /* 3c */ 0, 0, 0, 0,
+ /* 40 */ GROUP(243), GROUP(244), GROUP(245), 0,
+ /* 44 */ GROUP(246), 0, 0, 0,
+ /* 48 */ 0, 0, 0, 0,
+ /* 4c */ 0, 0, 0, 0,
+ /* 50 */ 0, 0, 0, 0,
+ /* 54 */ 0, 0, 0, 0,
+ /* 58 */ 0, 0, 0, 0,
+ /* 5c */ 0, 0, 0, 0,
+ /* 60 */ GROUP(247), GROUP(248), GROUP(249), GROUP(250),
+ /* 64 */ 0, 0, 0, 0,
+ /* 68 */ 0, 0, 0, 0,
+ /* 6c */ 0, 0, 0, 0,
+ /* 70 */ 0, 0, 0, 0,
+ /* 74 */ 0, 0, 0, 0,
+ /* 78 */ 0, 0, 0, 0,
+ /* 7c */ 0, 0, 0, 0,
+ /* 80 */ 0, 0, 0, 0,
+ /* 84 */ 0, 0, 0, 0,
+ /* 88 */ 0, 0, 0, 0,
+ /* 8c */ 0, 0, 0, 0,
+ /* 90 */ 0, 0, 0, 0,
+ /* 94 */ 0, 0, 0, 0,
+ /* 98 */ 0, 0, 0, 0,
+ /* 9c */ 0, 0, 0, 0,
+ /* a0 */ 0, 0, 0, 0,
+ /* a4 */ 0, 0, 0, 0,
+ /* a8 */ 0, 0, 0, 0,
+ /* ac */ 0, 0, 0, 0,
+ /* b0 */ 0, 0, 0, 0,
+ /* b4 */ 0, 0, 0, 0,
+ /* b8 */ 0, 0, 0, 0,
+ /* bc */ 0, 0, 0, 0,
+ /* c0 */ 0, 0, 0, 0,
+ /* c4 */ 0, 0, 0, 0,
+ /* c8 */ 0, 0, 0, 0,
+ /* cc */ 0, 0, 0, 0,
+ /* d0 */ 0, 0, 0, 0,
+ /* d4 */ 0, 0, 0, 0,
+ /* d8 */ 0, 0, 0, 0,
+ /* dc */ 0, 0, 0, GROUP(251),
+ /* e0 */ 0, 0, 0, 0,
+ /* e4 */ 0, 0, 0, 0,
+ /* e8 */ 0, 0, 0, 0,
+ /* ec */ 0, 0, 0, 0,
+ /* f0 */ 0, 0, 0, 0,
+ /* f4 */ 0, 0, 0, 0,
+ /* f8 */ 0, 0, 0, 0,
+ /* fc */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__252[] = {
+ /* 0 */ 265, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__253[] = {
+ /* 0 */ 266, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__254[] = {
+ /* 0 */ 267, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__255[] = {
+ /* 0 */ 268, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__256[] = {
+ /* 0 */ 269, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__257[] = {
+ /* 0 */ 270, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__258[] = {
+ /* 0 */ 271, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__259[] = {
+ /* 0 */ 272, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__260[] = {
+ /* 0 */ 273, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__261[] = {
+ /* 0 */ 274, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__262[] = {
+ /* 0 */ 275, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__263[] = {
+ /* 0 */ 276, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__264[] = {
+ /* 0 */ 277, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__265[] = {
+ /* 0 */ 278, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__266[] = {
+ /* 0 */ 279, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__267[] = {
+ /* 0 */ 280, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__268[] = {
+ /* 0 */ 281, 0, 0, 282,
+};
+
+static const uint16_t ud_itab__269[] = {
+ /* 0 */ 283, 284, 285, 286,
+};
+
+static const uint16_t ud_itab__270[] = {
+ /* 0 */ 287, 0, 288, 0,
+};
+
+static const uint16_t ud_itab__271[] = {
+ /* 0 */ 289, 0, 290, 0,
+};
+
+static const uint16_t ud_itab__272[] = {
+ /* 0 */ 291, 0, 0, 292,
+};
+
+static const uint16_t ud_itab__273[] = {
+ /* 0 */ 293, 0, 0, 294,
+};
+
+static const uint16_t ud_itab__274[] = {
+ /* 0 */ 295, 0, 0, 296,
+};
+
+static const uint16_t ud_itab__275[] = {
+ /* 0 */ 297, 0, 0, 298,
+};
+
+static const uint16_t ud_itab__276[] = {
+ /* 0 */ 299, 300, 301, 302,
+};
+
+static const uint16_t ud_itab__277[] = {
+ /* 0 */ 303, 304, 305, 306,
+};
+
+static const uint16_t ud_itab__278[] = {
+ /* 0 */ 307, 308, 309, 310,
+};
+
+static const uint16_t ud_itab__279[] = {
+ /* 0 */ 311, 0, 312, 313,
+};
+
+static const uint16_t ud_itab__280[] = {
+ /* 0 */ 314, 315, 316, 317,
+};
+
+static const uint16_t ud_itab__281[] = {
+ /* 0 */ 318, 319, 320, 321,
+};
+
+static const uint16_t ud_itab__282[] = {
+ /* 0 */ 322, 323, 324, 325,
+};
+
+static const uint16_t ud_itab__283[] = {
+ /* 0 */ 326, 327, 328, 329,
+};
+
+static const uint16_t ud_itab__284[] = {
+ /* 0 */ 330, 0, 0, 331,
+};
+
+static const uint16_t ud_itab__285[] = {
+ /* 0 */ 332, 0, 0, 333,
+};
+
+static const uint16_t ud_itab__286[] = {
+ /* 0 */ 334, 0, 0, 335,
+};
+
+static const uint16_t ud_itab__287[] = {
+ /* 0 */ 336, 0, 0, 337,
+};
+
+static const uint16_t ud_itab__288[] = {
+ /* 0 */ 338, 0, 0, 339,
+};
+
+static const uint16_t ud_itab__289[] = {
+ /* 0 */ 340, 0, 0, 341,
+};
+
+static const uint16_t ud_itab__290[] = {
+ /* 0 */ 342, 0, 0, 343,
+};
+
+static const uint16_t ud_itab__291[] = {
+ /* 0 */ 344, 0, 0, 345,
+};
+
+static const uint16_t ud_itab__292[] = {
+ /* 0 */ 346, 0, 0, 347,
+};
+
+static const uint16_t ud_itab__293[] = {
+ /* 0 */ 348, 0, 0, 349,
+};
+
+static const uint16_t ud_itab__294[] = {
+ /* 0 */ 350, 0, 0, 351,
+};
+
+static const uint16_t ud_itab__295[] = {
+ /* 0 */ 352, 0, 0, 353,
+};
+
+static const uint16_t ud_itab__296[] = {
+ /* 0 */ 0, 0, 0, 354,
+};
+
+static const uint16_t ud_itab__297[] = {
+ /* 0 */ 0, 0, 0, 355,
+};
+
+static const uint16_t ud_itab__298[] = {
+ /* 0 */ 356, 0, 0, 357,
+};
+
+static const uint16_t ud_itab__299[] = {
+ /* 0 */ 358, 0, 359, 360,
+};
+
+static const uint16_t ud_itab__300[] = {
+ /* 0 */ 361, 362, 363, 364,
+};
+
+static const uint16_t ud_itab__302[] = {
+ /* 0 */ 365, 0, 0, 366,
+};
+
+static const uint16_t ud_itab__303[] = {
+ /* 0 */ 367, 0, 0, 368,
+};
+
+static const uint16_t ud_itab__304[] = {
+ /* 0 */ 369, 0, 0, 370,
+};
+
+static const uint16_t ud_itab__301[] = {
+ /* 0 */ 0, 0, GROUP(302), 0,
+ /* 4 */ GROUP(303), 0, GROUP(304), 0,
+};
+
+static const uint16_t ud_itab__306[] = {
+ /* 0 */ 371, 0, 0, 372,
+};
+
+static const uint16_t ud_itab__307[] = {
+ /* 0 */ 373, 0, 0, 374,
+};
+
+static const uint16_t ud_itab__308[] = {
+ /* 0 */ 375, 0, 0, 376,
+};
+
+static const uint16_t ud_itab__305[] = {
+ /* 0 */ 0, 0, GROUP(306), 0,
+ /* 4 */ GROUP(307), 0, GROUP(308), 0,
+};
+
+static const uint16_t ud_itab__310[] = {
+ /* 0 */ 377, 0, 0, 378,
+};
+
+static const uint16_t ud_itab__311[] = {
+ /* 0 */ 0, 0, 0, 379,
+};
+
+static const uint16_t ud_itab__312[] = {
+ /* 0 */ 380, 0, 0, 381,
+};
+
+static const uint16_t ud_itab__313[] = {
+ /* 0 */ 0, 0, 0, 382,
+};
+
+static const uint16_t ud_itab__309[] = {
+ /* 0 */ 0, 0, GROUP(310), GROUP(311),
+ /* 4 */ 0, 0, GROUP(312), GROUP(313),
+};
+
+static const uint16_t ud_itab__314[] = {
+ /* 0 */ 383, 0, 0, 384,
+};
+
+static const uint16_t ud_itab__315[] = {
+ /* 0 */ 385, 0, 0, 386,
+};
+
+static const uint16_t ud_itab__316[] = {
+ /* 0 */ 387, 0, 0, 388,
+};
+
+static const uint16_t ud_itab__317[] = {
+ /* 0 */ 389, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__319[] = {
+ /* 0 */ 0, 390, 0,
+};
+
+static const uint16_t ud_itab__318[] = {
+ /* 0 */ GROUP(319), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__321[] = {
+ /* 0 */ 0, 391, 0,
+};
+
+static const uint16_t ud_itab__320[] = {
+ /* 0 */ GROUP(321), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__322[] = {
+ /* 0 */ 0, 392, 0, 393,
+};
+
+static const uint16_t ud_itab__323[] = {
+ /* 0 */ 0, 394, 0, 395,
+};
+
+static const uint16_t ud_itab__324[] = {
+ /* 0 */ 396, 0, 397, 398,
+};
+
+static const uint16_t ud_itab__325[] = {
+ /* 0 */ 399, 0, 400, 401,
+};
+
+static const uint16_t ud_itab__326[] = {
+ /* 0 */ 402, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__327[] = {
+ /* 0 */ 403, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__328[] = {
+ /* 0 */ 404, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__329[] = {
+ /* 0 */ 405, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__330[] = {
+ /* 0 */ 406, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__331[] = {
+ /* 0 */ 407, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__332[] = {
+ /* 0 */ 408, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__333[] = {
+ /* 0 */ 409, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__334[] = {
+ /* 0 */ 410, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__335[] = {
+ /* 0 */ 411, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__336[] = {
+ /* 0 */ 412, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__337[] = {
+ /* 0 */ 413, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__338[] = {
+ /* 0 */ 414, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__339[] = {
+ /* 0 */ 415, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__340[] = {
+ /* 0 */ 416, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__341[] = {
+ /* 0 */ 417, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__342[] = {
+ /* 0 */ 418, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__343[] = {
+ /* 0 */ 419, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__344[] = {
+ /* 0 */ 420, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__345[] = {
+ /* 0 */ 421, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__346[] = {
+ /* 0 */ 422, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__347[] = {
+ /* 0 */ 423, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__348[] = {
+ /* 0 */ 424, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__349[] = {
+ /* 0 */ 425, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__350[] = {
+ /* 0 */ 426, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__351[] = {
+ /* 0 */ 427, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__352[] = {
+ /* 0 */ 428, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__353[] = {
+ /* 0 */ 429, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__354[] = {
+ /* 0 */ 430, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__355[] = {
+ /* 0 */ 431, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__356[] = {
+ /* 0 */ 432, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__357[] = {
+ /* 0 */ 433, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__358[] = {
+ /* 0 */ 434, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__359[] = {
+ /* 0 */ 435, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__360[] = {
+ /* 0 */ 436, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__361[] = {
+ /* 0 */ 437, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__362[] = {
+ /* 0 */ 438, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__363[] = {
+ /* 0 */ 439, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__368[] = {
+ /* 0 */ 0, 440,
+};
+
+static const uint16_t ud_itab__367[] = {
+ /* 0 */ GROUP(368), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__366[] = {
+ /* 0 */ GROUP(367), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__371[] = {
+ /* 0 */ 0, 441,
+};
+
+static const uint16_t ud_itab__370[] = {
+ /* 0 */ GROUP(371), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__369[] = {
+ /* 0 */ GROUP(370), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__374[] = {
+ /* 0 */ 0, 442,
+};
+
+static const uint16_t ud_itab__373[] = {
+ /* 0 */ GROUP(374), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__372[] = {
+ /* 0 */ GROUP(373), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__365[] = {
+ /* 0 */ GROUP(366), GROUP(369), GROUP(372), 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__364[] = {
+ /* 0 */ 0, GROUP(365),
+};
+
+static const uint16_t ud_itab__379[] = {
+ /* 0 */ 0, 443,
+};
+
+static const uint16_t ud_itab__378[] = {
+ /* 0 */ GROUP(379), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__377[] = {
+ /* 0 */ GROUP(378), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__382[] = {
+ /* 0 */ 0, 444,
+};
+
+static const uint16_t ud_itab__381[] = {
+ /* 0 */ GROUP(382), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__380[] = {
+ /* 0 */ GROUP(381), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__385[] = {
+ /* 0 */ 0, 445,
+};
+
+static const uint16_t ud_itab__384[] = {
+ /* 0 */ GROUP(385), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__383[] = {
+ /* 0 */ GROUP(384), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__388[] = {
+ /* 0 */ 0, 446,
+};
+
+static const uint16_t ud_itab__387[] = {
+ /* 0 */ GROUP(388), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__386[] = {
+ /* 0 */ GROUP(387), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__391[] = {
+ /* 0 */ 0, 447,
+};
+
+static const uint16_t ud_itab__390[] = {
+ /* 0 */ GROUP(391), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__389[] = {
+ /* 0 */ GROUP(390), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__394[] = {
+ /* 0 */ 0, 448,
+};
+
+static const uint16_t ud_itab__393[] = {
+ /* 0 */ GROUP(394), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__392[] = {
+ /* 0 */ GROUP(393), 0, 0, 0,
+ /* 4 */ 0, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__376[] = {
+ /* 0 */ GROUP(377), GROUP(380), GROUP(383), GROUP(386),
+ /* 4 */ GROUP(389), GROUP(392), 0, 0,
+};
+
+static const uint16_t ud_itab__375[] = {
+ /* 0 */ 0, GROUP(376),
+};
+
+static const uint16_t ud_itab__395[] = {
+ /* 0 */ 449, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__396[] = {
+ /* 0 */ 450, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__397[] = {
+ /* 0 */ 451, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__398[] = {
+ /* 0 */ 452, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__399[] = {
+ /* 0 */ 453, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__400[] = {
+ /* 0 */ 454, 0, 0, 0,
+};
+
+static const uint16_t ud_itab__404[] = {
+ /* 0 */ 455, 0,
+};
+
+static const uint16_t ud_itab__403[] = {
+ /* 0 */ GROUP(404), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__406[] = {
+ /* 0 */ 456, 0,
+};
+
+static const uint16_t ud_itab__405[] = {
+ /* 0 */ GROUP(406), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__408[] = {
+ /* 0 */ 457, 0,
+};
+
+static const uint16_t ud_itab__407[] = {
+ /* 0 */ GROUP(408), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__410[] = {
+ /* 0 */ 458, 0,
+};
+
+static const uint16_t ud_itab__409[] = {
+ /* 0 */ GROUP(410), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__412[] = {
+ /* 0 */ 459, 0,
+};
+
+static const uint16_t ud_itab__411[] = {
+ /* 0 */ GROUP(412), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__414[] = {
+ /* 0 */ 460, 0,
+};
+
+static const uint16_t ud_itab__413[] = {
+ /* 0 */ GROUP(414), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__416[] = {
+ /* 0 */ 461, 0,
+};
+
+static const uint16_t ud_itab__415[] = {
+ /* 0 */ GROUP(416), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__402[] = {
+ /* 0 */ GROUP(403), GROUP(405), GROUP(407), GROUP(409),
+ /* 4 */ GROUP(411), GROUP(413), 0, GROUP(415),
+};
+
+static const uint16_t ud_itab__420[] = {
+ /* 0 */ 0, 462,
+};
+
+static const uint16_t ud_itab__419[] = {
+ /* 0 */ GROUP(420), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__422[] = {
+ /* 0 */ 0, 463,
+};
+
+static const uint16_t ud_itab__421[] = {
+ /* 0 */ GROUP(422), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__424[] = {
+ /* 0 */ 0, 464,
+};
+
+static const uint16_t ud_itab__423[] = {
+ /* 0 */ GROUP(424), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__426[] = {
+ /* 0 */ 0, 465,
+};
+
+static const uint16_t ud_itab__425[] = {
+ /* 0 */ GROUP(426), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__428[] = {
+ /* 0 */ 0, 466,
+};
+
+static const uint16_t ud_itab__427[] = {
+ /* 0 */ GROUP(428), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__430[] = {
+ /* 0 */ 0, 467,
+};
+
+static const uint16_t ud_itab__429[] = {
+ /* 0 */ GROUP(430), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__432[] = {
+ /* 0 */ 0, 468,
+};
+
+static const uint16_t ud_itab__431[] = {
+ /* 0 */ GROUP(432), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__434[] = {
+ /* 0 */ 0, 469,
+};
+
+static const uint16_t ud_itab__433[] = {
+ /* 0 */ GROUP(434), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__418[] = {
+ /* 0 */ GROUP(419), GROUP(421), GROUP(423), GROUP(425),
+ /* 4 */ GROUP(427), GROUP(429), GROUP(431), GROUP(433),
+};
+
+static const uint16_t ud_itab__437[] = {
+ /* 0 */ 0, 470,
+};
+
+static const uint16_t ud_itab__436[] = {
+ /* 0 */ GROUP(437), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__439[] = {
+ /* 0 */ 0, 471,
+};
+
+static const uint16_t ud_itab__438[] = {
+ /* 0 */ GROUP(439), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__441[] = {
+ /* 0 */ 0, 472,
+};
+
+static const uint16_t ud_itab__440[] = {
+ /* 0 */ GROUP(441), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__443[] = {
+ /* 0 */ 0, 473,
+};
+
+static const uint16_t ud_itab__442[] = {
+ /* 0 */ GROUP(443), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__445[] = {
+ /* 0 */ 0, 474,
+};
+
+static const uint16_t ud_itab__444[] = {
+ /* 0 */ GROUP(445), 0, 0, 0,
+};
+
+static const uint16_t ud_itab__447[] = {
+ /* 0 */ 0, 475,
+};
+
+static const uint16_t ud_itab__446[] = {
+ /* 0 */ GROUP(447), 0,[...]
[diff truncated at 100000 bytes]
